using System;
using System.Text;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using NUnit.Framework;
using AjaxControlToolkit;

namespace AjaxControlToolkit.Models.NUnitClassic
{
	
	public partial class MaskedEditValidatorTests
	{


        
		[Test]
        public void MaskedEditValidatorTests_Property_ErrorMessage_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.String defaultValue;
            try
            {
                defaultValue = objectUnderTest.ErrorMessage;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.ErrorMessage = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.ErrorMessage);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_IsValidEmpty_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.Boolean defaultValue;
            try
            {
                defaultValue = objectUnderTest.IsValidEmpty;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.IsValidEmpty = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.IsValidEmpty);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_TooltipMessage_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.String defaultValue;
            try
            {
                defaultValue = objectUnderTest.TooltipMessage;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.TooltipMessage = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.TooltipMessage);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_EmptyValueMessage_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.String defaultValue;
            try
            {
                defaultValue = objectUnderTest.EmptyValueMessage;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.EmptyValueMessage = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.EmptyValueMessage);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_EmptyValueBlurredText_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.String defaultValue;
            try
            {
                defaultValue = objectUnderTest.EmptyValueBlurredText;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.EmptyValueBlurredText = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.EmptyValueBlurredText);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_InvalidValueMessage_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.String defaultValue;
            try
            {
                defaultValue = objectUnderTest.InvalidValueMessage;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.InvalidValueMessage = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.InvalidValueMessage);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_InvalidValueBlurredMessage_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.String defaultValue;
            try
            {
                defaultValue = objectUnderTest.InvalidValueBlurredMessage;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.InvalidValueBlurredMessage = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.InvalidValueBlurredMessage);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_MaximumValue_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.String defaultValue;
            try
            {
                defaultValue = objectUnderTest.MaximumValue;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.MaximumValue = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.MaximumValue);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_MaximumValueMessage_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.String defaultValue;
            try
            {
                defaultValue = objectUnderTest.MaximumValueMessage;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.MaximumValueMessage = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.MaximumValueMessage);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_MaximumValueBlurredMessage_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.String defaultValue;
            try
            {
                defaultValue = objectUnderTest.MaximumValueBlurredMessage;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.MaximumValueBlurredMessage = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.MaximumValueBlurredMessage);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_ClientValidationFunction_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.String defaultValue;
            try
            {
                defaultValue = objectUnderTest.ClientValidationFunction;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.ClientValidationFunction = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.ClientValidationFunction);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_InitialValue_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.String defaultValue;
            try
            {
                defaultValue = objectUnderTest.InitialValue;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.InitialValue = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.InitialValue);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_ValidationExpression_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.String defaultValue;
            try
            {
                defaultValue = objectUnderTest.ValidationExpression;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.ValidationExpression = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.ValidationExpression);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_MinimumValue_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.String defaultValue;
            try
            {
                defaultValue = objectUnderTest.MinimumValue;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.MinimumValue = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.MinimumValue);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_MinimumValueMessage_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.String defaultValue;
            try
            {
                defaultValue = objectUnderTest.MinimumValueMessage;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.MinimumValueMessage = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.MinimumValueMessage);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_MinimumValueBlurredText_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.String defaultValue;
            try
            {
                defaultValue = objectUnderTest.MinimumValueBlurredText;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.MinimumValueBlurredText = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.MinimumValueBlurredText);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_ControlExtender_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.String defaultValue;
            try
            {
                defaultValue = objectUnderTest.ControlExtender;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.ControlExtender = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.ControlExtender);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_AssociatedControlID_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.String defaultValue;
            try
            {
                defaultValue = objectUnderTest.AssociatedControlID;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.AssociatedControlID = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.AssociatedControlID);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_ForeColor_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.Drawing.Color defaultValue;
            try
            {
                defaultValue = objectUnderTest.ForeColor;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.ForeColor = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.ForeColor);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_ControlToValidate_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.String defaultValue;
            try
            {
                defaultValue = objectUnderTest.ControlToValidate;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.ControlToValidate = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.ControlToValidate);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_EnableClientScript_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.Boolean defaultValue;
            try
            {
                defaultValue = objectUnderTest.EnableClientScript;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.EnableClientScript = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.EnableClientScript);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_Enabled_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.Boolean defaultValue;
            try
            {
                defaultValue = objectUnderTest.Enabled;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.Enabled = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.Enabled);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_IsValid_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.Boolean defaultValue;
            try
            {
                defaultValue = objectUnderTest.IsValid;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.IsValid = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.IsValid);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_Display_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.Web.UI.WebControls.ValidatorDisplay defaultValue;
            try
            {
                defaultValue = objectUnderTest.Display;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.Display = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.Display);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_SetFocusOnError_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.Boolean defaultValue;
            try
            {
                defaultValue = objectUnderTest.SetFocusOnError;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.SetFocusOnError = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.SetFocusOnError);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_Text_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.String defaultValue;
            try
            {
                defaultValue = objectUnderTest.Text;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.Text = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.Text);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_ValidationGroup_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.String defaultValue;
            try
            {
                defaultValue = objectUnderTest.ValidationGroup;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.ValidationGroup = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.ValidationGroup);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_AccessKey_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.String defaultValue;
            try
            {
                defaultValue = objectUnderTest.AccessKey;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.AccessKey = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.AccessKey);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_BackColor_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.Drawing.Color defaultValue;
            try
            {
                defaultValue = objectUnderTest.BackColor;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.BackColor = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.BackColor);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_BorderColor_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.Drawing.Color defaultValue;
            try
            {
                defaultValue = objectUnderTest.BorderColor;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.BorderColor = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.BorderColor);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_BorderWidth_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.Web.UI.WebControls.Unit defaultValue;
            try
            {
                defaultValue = objectUnderTest.BorderWidth;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.BorderWidth = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.BorderWidth);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_BorderStyle_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.Web.UI.WebControls.BorderStyle defaultValue;
            try
            {
                defaultValue = objectUnderTest.BorderStyle;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.BorderStyle = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.BorderStyle);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_CssClass_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.String defaultValue;
            try
            {
                defaultValue = objectUnderTest.CssClass;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.CssClass = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.CssClass);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_EnableTheming_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.Boolean defaultValue;
            try
            {
                defaultValue = objectUnderTest.EnableTheming;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.EnableTheming = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.EnableTheming);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_Height_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.Web.UI.WebControls.Unit defaultValue;
            try
            {
                defaultValue = objectUnderTest.Height;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.Height = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.Height);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_SkinID_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.String defaultValue;
            try
            {
                defaultValue = objectUnderTest.SkinID;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.SkinID = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.SkinID);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_TabIndex_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.Int16 defaultValue;
            try
            {
                defaultValue = objectUnderTest.TabIndex;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.TabIndex = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.TabIndex);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_ToolTip_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.String defaultValue;
            try
            {
                defaultValue = objectUnderTest.ToolTip;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.ToolTip = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.ToolTip);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_Width_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.Web.UI.WebControls.Unit defaultValue;
            try
            {
                defaultValue = objectUnderTest.Width;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.Width = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.Width);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_ClientIDMode_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.Web.UI.ClientIDMode defaultValue;
            try
            {
                defaultValue = objectUnderTest.ClientIDMode;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.ClientIDMode = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.ClientIDMode);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_ID_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.String defaultValue;
            try
            {
                defaultValue = objectUnderTest.ID;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.ID = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.ID);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_EnableViewState_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.Boolean defaultValue;
            try
            {
                defaultValue = objectUnderTest.EnableViewState;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.EnableViewState = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.EnableViewState);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_ViewStateMode_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.Web.UI.ViewStateMode defaultValue;
            try
            {
                defaultValue = objectUnderTest.ViewStateMode;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.ViewStateMode = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.ViewStateMode);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_Page_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.Web.UI.Page defaultValue;
            try
            {
                defaultValue = objectUnderTest.Page;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.Page = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.Page);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_RenderingCompatibility_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.Version defaultValue;
            try
            {
                defaultValue = objectUnderTest.RenderingCompatibility;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.RenderingCompatibility = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.RenderingCompatibility);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_TemplateControl_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.Web.UI.TemplateControl defaultValue;
            try
            {
                defaultValue = objectUnderTest.TemplateControl;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.TemplateControl = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.TemplateControl);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_AppRelativeTemplateSourceDirectory_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.String defaultValue;
            try
            {
                defaultValue = objectUnderTest.AppRelativeTemplateSourceDirectory;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.AppRelativeTemplateSourceDirectory = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.AppRelativeTemplateSourceDirectory);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_Site_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.ComponentModel.ISite defaultValue;
            try
            {
                defaultValue = objectUnderTest.Site;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.Site = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.Site);;

		}    
        
        
		[Test]
        public void MaskedEditValidatorTests_Property_Visible_SelfAssign ()
		{
			var objectUnderTest = CreateObject();
			
			System.Boolean defaultValue;
            try
            {
                defaultValue = objectUnderTest.Visible;
            }
            catch (Exception ex)
            {
                Assert.Inconclusive("Could not complete test. Error reading property." + Environment.NewLine + ex.ToString());
                return;
            }
            
			objectUnderTest.Visible = defaultValue;
			Assert.AreEqual(defaultValue, objectUnderTest.Visible);;

		}    
        
	}
}

